Previously, when returning data from a resource that was paginated, we
would parse the pagination args off the resposne, loop over the "data"
value in the response, and map each item in the JSON array to a
specific resource. An example of this would be in the listUsers() method
of the UserManagement class (truncated example below):

```php
$users = [];

list($before, $after) = Util\Request::parsePaginationArgs($response);
foreach ($response["data"] as $responseData) {
    \array_push($users, Resource\User::constructFromResponse($responseData));
}

return [$before, $after, $users];
```

Performing this pattern over and over again resulted in a lot of
duplicate code that was doing basically nothing more than an array_map.

Additionally, this return is extremely limited and forces the user into
a limited and specific pattern of either bare array destructuring:

```php
[$before, $after, $users] = $userManagement->listUsers();
```

Or dealing with 0-indexed array values:

```php
$result = $userManagement->listUsers();
```

If for example they just want the first 5 users and don't care about paginating,
this means they'd to either write destructuring that has empty values:

```php
// Huh?
[,,$users] = $userManagement->listUsers(limit: 5);
```

Or they'd have to drop down to

```php
$results = $userManagement->listUsers(limit: 5);
// How do I discover or know what this index is?
$users = $results[2];
```

To fix both of these issues, without affecting current library
consumers, I'm proposing that we create a `Resource\PaginatedResource` class that:

1. DRYs and standardizes the creation of a paginated resource
2. Handles the resource mapping from the data array
3. Continues to allow for bare destructuring (backwards compatible)
4. Introduces named destructuring (e.g `$result["after"]` or
`["users" => $fiveUsers] = $userManagement->listUsers(limit:5)`)
5. Introduces fluent property access (e.g. `$result->after` or
`$result->users`)

The change is fully backwards compatible, cleans up existing resource
code and allows for developers to use the library in whichever code
style is consistent with their project.

For example, it lets you turn this code:

```php
[$before, $after, $users] = $userManagement->listUsers();

while ($after) {
    [$before, $after, $currentPage] = $sso->listConnections(
        limit: 100,
        after: $after,
        order: "desc"
    );

    $users = array_merge($users, $currentPage);
}
```

Into this code:

```php
$users = [];
$after = null;

do {
    $result = $userManagement->listUsers(after: $after, limit: 10);
    $users = array_merge($allUsers, $result->users);
    $after = $result->after;
} while ($after !== null);
```